package com.basic.business.packaging.server;

import com.basic.business.common.constants.Constants;
import com.basic.business.common.constants.KmConstants;
import com.basic.business.common.enums.OrdersStatusEnum;
import com.basic.business.common.redis.RedisCacheUtils;
import com.basic.business.common.utils.DateUtils;
import com.basic.business.common.utils.FileUtils;
import com.basic.business.common.utils.SpringUtils;
import com.basic.business.common.utils.StringUtils;
import com.basic.business.common.utils.kmUtil.TagUtils;
import com.basic.business.img.domain.TImagesInfo;
import com.basic.business.img.service.ITImagesInfoService;
import com.basic.business.log.domain.TOrdersLog;
import com.basic.business.log.service.ITOrdersLogService;
import com.basic.business.order.domain.TOrdersDetail;
import com.basic.business.order.domain.TOrdersMain;
import com.basic.business.order.domain.TOrdersMerge;
import com.basic.business.order.service.ITOrdersMainService;
import com.basic.business.pathRel.domain.TPathRel;
import com.basic.business.prodRel.domain.TProdRelDetails;
import com.basic.business.redis.domain.TOrdersDetailRedis;
import com.basic.business.redis.domain.TOrdersMainRedis;
import com.basic.business.shift.domain.TShiftMgmt;
import com.basic.business.store.domain.TStoreMgmt;
import com.basic.business.wechat.WeChatUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

/**
 * 自动打包服务
 *
 * @author zhaoxy_jn@163.com
 */
@Component
@Slf4j
public class AutomaticPackagingServer {

    private static final ExecutorService executor = Executors.newCachedThreadPool();
    private static final ConcurrentMap<Long, Future<?>> fileTasks = new ConcurrentHashMap<>();
    /**
     * 初始化自动打包服务
     */
    public static void TimerInit(List<TOrdersMain> ordersMains) {
        try {
            ordersMains.forEach(AutomaticPackagingServer::prePackage);
        } catch (Exception e) {
            log.error("自动打包服务失败", e);
        }

    }

    /**
     * 预处理订单
     * A.主订单状态：CLOSED（交易关闭）、CANCEL（交易取消）、FINISHED（交易完成）的，直接删除打包文件，删除Redis中的信息
     * B.主订单状态：WAIT_AUDIT（待审核）
     *  B1.订单明细备注包含【人工处理】更新Redis中自动处理状态为false，删除不做处理的标签，新增正常处理标签
     *  B2.合单明细状态中有CLOSED（交易关闭）、CANCEL（交易取消）的且isMergeMain是0的，用此状态的sid到Redis中获取订单信息
     *      B21.若能获取到，说明是原来的主订单退款的，删除原订单打包文件，删除Redis中的信息
     *      B22.若不能获取到，说明是子订单退款，删除子订单打包文件，更新子订单自动处理状态为false
     *  B3.打包（订单明细状态是WAIT_AUDIT，isGit是N）
     *      B31.判断是否全是印刷品，是则新增印刷品标签，删除不做处理标签，删除正常处理标签，更新Redis自动处理状态为true
     *      B32.不全是印刷品，判断订单是否outerSkuId包含26位编码
     *          B321.不满足，新增正常处理标签，删除不做处理标签，删除印刷品标签，更新Redis自动处理状态为false
     *          B322.满足
     *              B3221.全是26位编码的
     *
     *
     *                  处理成功，更新Redis中自动处理状态为true，新增不做处理标签，删除正常处理标签，删除印刷品标签；
     *              B3222.处理失败，更新Redis中自动处理状态为false，新增正常处理标签
     *  B4.已经做包，且备注有【收据】，需要修改原文件路径和数据库记录的路径
     *
     */
    private static void prePackage(TOrdersMain ordersMain){

        // 主订单状态：CLOSED（交易关闭）、CANCEL（交易取消）、FINISHED（交易完成）的，直接删除打包文件，删除Redis中的信息
        if (StringUtils.containsAny(ordersMain.getSysStatus(), "CLOSED", "CANCEL", "FINISHED")) {
            boolean isSuccess = conditionA(ordersMain);
            // 更新主订单中的自动处理状态
            SpringUtils.getBean(ITOrdersMainService.class).updateAutoProcessStatus(ordersMain.getSid(), "PROCESS_FINISH");
            return;
        }

        // 主订单状态：WAIT_AUDIT（待审核）
        if (StringUtils.equals(ordersMain.getSysStatus(), "WAIT_AUDIT")) {

            conditionB(ordersMain);
        }

    }

    // 取消文件生成任务
    public static void cancelFileGeneration(Long taskId) {
        Future<?> future = fileTasks.get(taskId);
        if (future != null) {
            future.cancel(true); // 中断执行
            fileTasks.remove(taskId);
            System.out.println("任务已取消: " + taskId);
        }
    }

    // 任务取消后的处理
    private static void handleTaskCancellation(Long taskId) {
        System.out.println("执行清理操作: " + taskId);
    }

    /**
     * 条件A处理
     */
    private static boolean conditionA(TOrdersMain ordersMain){
        boolean isSuccess = false;
        try {
            ordersMain.getDetailList().forEach(detail -> {
                // 删除打包文件
                delFileBySid(ordersMain, detail.getDetailSid());
            });

            // 从Redis中删除
            RedisCacheUtils.deleteObject(Constants.ORDERS_REDIS_KEY + ordersMain.getSid());
            isSuccess = true;
        } catch (Exception e) {
            log.error("自动打包服务失败", e);
        }
        return isSuccess;
    }

    /**
     * 条件B处理
     */
    private static void conditionB(TOrdersMain ordersMain){
        try{
            // 订单明细备注包含【人工处理】更新Redis中自动处理状态为false，删除不做处理的标签，新增正常处理标签
            boolean isContainB1 = conditionB1(ordersMain);
            if (isContainB1) return;

            // 合单明细状态中有CLOSED（交易关闭）、CANCEL（交易取消）的且isMergeMain是0的，用此状态的sid到Redis中获取订单信息
            boolean isContainB2 = conditionB2(ordersMain);

            // 打包（订单明细状态是WAIT_AUDIT，isGit是N）
            conditionB3(ordersMain);

            // 已经做包，且备注有【收据】，需要修改原文件路径和数据库记录的路径
            conditionB4(ordersMain);

            // 已经做包，且备注有【中通快递】，需要修改原文件路径和数据库记录的路径
            conditionB5(ordersMain);

            // 已经做包，且备注有【顺丰到付】【顺丰现付】，需要修改原文件路径和数据库记录的路径
            conditionB6(ordersMain);

        }catch (Exception e) {
            // 更新主订单中的自动处理状态
            SpringUtils.getBean(ITOrdersMainService.class).updateAutoProcessStatus(ordersMain.getSid(), "PROCESS_FAILED");
            return;
        }
        // 更新主订单中的自动处理状态
        SpringUtils.getBean(ITOrdersMainService.class).updateAutoProcessStatus(ordersMain.getSid(), "PROCESS_FINISH");

    }

    /**
     * 订单明细备注包含【人工处理】更新Redis中自动处理状态为false，删除不做处理的标签，新增正常处理标签
     */
    private static boolean conditionB1(TOrdersMain ordersMain){
        try {
            // 判断订单明细备注中是否包含【人工处理】
            boolean isDetailsContains = ordersMain.getDetailList().stream().anyMatch(detail -> StringUtils.contains(detail.getSellerMemo(), "【人工处理】"));
            boolean isMainContains = StringUtils.contains(ordersMain.getSellerMemo(), "【人工处理】");
            // 获取Redis中的订单信息
            TOrdersMainRedis mainRedis = RedisCacheUtils.getCacheObject(Constants.ORDERS_REDIS_KEY + ordersMain.getSid());

            boolean isAutoProcessed = mainRedis.getDetailList().stream().anyMatch(TOrdersDetailRedis::isAutoProcessed);

            if (isDetailsContains || isMainContains) {
                // 系统订单号
                long sid = ordersMain.getSid();

                // Redis中自动处理设置为false
                mainRedis.getDetailList().forEach(detail -> detail.setAutoProcessed(false));
                RedisCacheUtils.setCacheObject(Constants.ORDERS_REDIS_KEY + ordersMain.getSid(), mainRedis);

                // 更新标签
                updateTags(sid, mainRedis, false, false);
                // 人工处理的删除整个包做的文件
                delFileByMainSid(ordersMain);
                return true;
            }
        }catch (Exception e) {
            return false;
        }
        return false;
    }

    /**
     * 合单明细状态中有CLOSED（交易关闭）、CANCEL（交易取消）的且isMergeMain是0的，用此状态的sid到Redis中获取订单信息
     */
    private static boolean conditionB2(TOrdersMain ordersMain){
        AtomicBoolean isContainB2 = new AtomicBoolean(false);
        try {
            // 判断合单明细状态是否存在CLOSED（交易关闭）、CANCEL（交易取消）的，并判断合单信息中isMergeMain是0的sid是否在Redis中存在
            List<TOrdersMerge> mergeCollect = ordersMain.getMergeList().stream().filter(merge -> StringUtils.containsAny(merge.getSysStatus(), "CLOSED", "CANCEL")).filter(merge -> merge.getIsMergeMain() == 0).collect(Collectors.toList());

            mergeCollect.forEach(merge -> {
                // 获取Redis中的订单信息
                TOrdersMainRedis mainRedis = RedisCacheUtils.getCacheObject(Constants.ORDERS_REDIS_KEY + merge.getMergeSid());
                if (Objects.nonNull(mainRedis)) {
                    // 若能获取到，说明是原来的主订单退款的，删除原订单打包文件，删除Redis中的信息
                    isContainB2.set(conditionB21(ordersMain, merge.getMergeSid()));
                } else {
                    // 若不能获取到，说明是子订单退款，删除子订单打包文件，更新子订单自动处理状态为false
                    isContainB2.set(conditionB22(ordersMain, merge.getMergeSid()));
                }
            });
        }catch (Exception e) {
            return false;
        }
        return isContainB2.get();
    }

    /**
     * 若能获取到，说明是原来的主订单退款的，删除原订单打包文件，删除Redis中的信息
     * @param sid 原来Redis中的key值
     */
    private static boolean conditionB21(TOrdersMain ordersMain, long sid) {
        try {
            // 根据sid 获取订单信息
            TOrdersMainRedis mainRedis = RedisCacheUtils.getCacheObject(Constants.ORDERS_REDIS_KEY + sid);
            // 删除打包文件
            mainRedis.getDetailList().forEach(detail -> {
                // 删除打包文件
                delFileBySid(ordersMain, detail.getDetailSid());
            });
            // 删除Redis信息
            RedisCacheUtils.deleteObject(Constants.ORDERS_REDIS_KEY + sid);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    /**
     * 若不能获取到，说明是子订单退款，删除子订单打包文件，更新子订单自动处理状态为false
     * @param ordersMain 主订单信息
     * @param mergeSid isMergeMain为0的sid
     */
    private static boolean conditionB22(TOrdersMain ordersMain,long mergeSid){
        try {
            TOrdersMainRedis mainRedis = RedisCacheUtils.getCacheObject(Constants.ORDERS_REDIS_KEY + ordersMain.getSid());

            mainRedis.getDetailList().forEach(detail -> {
                // 子订单sid和mergeSid相同，且自动处理为true的，删除打包文件，更新子订单自动处理状态为false
                if (detail.getDetailSid() == mergeSid && detail.isAutoProcessed()) {
                    // 删除打包文件
                    delFileBySid(ordersMain, mergeSid);
                    // 更新子订单自动处理状态为false
                    detail.setAutoProcessed(false);
                }
            });
            // 更新Redis信息
            RedisCacheUtils.setCacheObject(Constants.ORDERS_REDIS_KEY + ordersMain.getSid(), mainRedis);
            return true;
        }catch (Exception e) {
            return false;
        }
    }

    /**
     * 打包（订单明细状态是WAIT_AUDIT，isGit是N）
     */
    private static void conditionB3(TOrdersMain ordersMain){

        // 过滤所有的订单明细状态是WAIT_AUDIT的，且非赠品
        List<TOrdersDetail> detailCollect = ordersMain.getDetailList().stream().filter(detail -> StringUtils.equals(detail.getSysStatus(), "WAIT_AUDIT")).filter(detail -> StringUtils.equals(detail.getIsGift(), "N")).collect(Collectors.toList());
        if (!detailCollect.isEmpty()) {
            // 系统订单号
            long mainSid = ordersMain.getSid();

            // 获取印刷品集合
            List<String> printList = RedisCacheUtils.getCacheObject(Constants.PRINTS_REDIS_KEY);

            // 获取Redis信息
            TOrdersMainRedis mainRedis = RedisCacheUtils.getCacheObject(Constants.ORDERS_REDIS_KEY + mainSid);

            // 判断是否全是印刷品，是则新增印刷品标签，删除不做处理标签，删除正常处理标签，更新Redis自动处理状态为true
            boolean isConditionMet = conditionB31(detailCollect, mainSid, printList, mainRedis);
            if (!isConditionMet) {
                // 不全是印刷品，判断订单是否outerSkuId包含26位编码或印刷品编码
                conditionB32(ordersMain, detailCollect, mainSid, mainRedis);
            }
            // 更新Redis信息
            RedisCacheUtils.setCacheObject(Constants.ORDERS_REDIS_KEY + mainSid, mainRedis);

        }
    }

    /**
     * 判断是否全是印刷品，是则新增印刷品标签，删除不做处理标签，删除正常处理标签，更新Redis自动处理状态为true
     */
    private static boolean conditionB31(List<TOrdersDetail> detailCollect, long mainSid, List<String> printList, TOrdersMainRedis mainRedis){
        try {

            // 是否全是印刷品
            boolean isAllPrint = detailCollect.stream().allMatch(detail -> printList.stream().anyMatch(code -> StringUtils.contains(detail.getOuterSkuId(), code)));

            // 如果全是印刷品，是则新增印刷品标签，删除不做处理标签，删除正常处理标签，否则删除印刷品标签
            if (isAllPrint) {
                // 更新标签
                updateTags(mainSid, mainRedis, true, false);

                // 更新子订单自动处理状态为true
                mainRedis.getDetailList().forEach(detail -> detail.setAutoProcessed(true));
                return true;
            }
            return false;
        } catch (Exception e) {
            log.error("【印刷品标签更新失败】，错误信息--->{}", e.getMessage());
            return false;
        }
    }

    /**
     * 不全是印刷品，判断订单是否outerSkuId包含26位编码
     */
    private static void conditionB32(TOrdersMain ordersMain, List<TOrdersDetail> detailCollect, long mainSid, TOrdersMainRedis mainRedis){
        // 明细全部满足 26位编码
        boolean isContain26 = detailCollect.stream().allMatch(detail -> detail.getOuterSkuId().matches("^[0-9a-zA-z]{26}$"));
        if (!isContain26) {
            // 不满足，新增正常处理标签，删除不做处理标签，删除印刷品标签，更新Redis自动处理状态为false
            conditionB321(ordersMain, mainSid, mainRedis);
        } else {
            // 全是26位编码的
            conditionB322(detailCollect, mainSid, mainRedis);
        }
    }

    /**
     * 不满足，新增正常处理标签，删除不做处理标签，删除印刷品标签，更新Redis自动处理状态为false
     */
    private static void conditionB321(TOrdersMain ordersMain, long mainSid, TOrdersMainRedis mainRedis) {
        // 更新标签
        updateTags(mainSid, mainRedis, false, false);
        // 更新子订单自动处理状态为false
        mainRedis.getDetailList().forEach(detail -> detail.setAutoProcessed(false));
        // 删除打包文件
        delFileByMainSid(ordersMain);
    }

    /**
     * 全是26位编码的
     */
    private static void conditionB322(List<TOrdersDetail> detailCollect, long mainSid, TOrdersMainRedis mainRedis) {

        List<TOrdersDetail> detail26List = get26CodeOrderList(detailCollect);
        // 处理成功，更新Redis中自动处理状态为true，新增不做处理标签，删除正常处理标签，删除印刷品标签； 处理失败，更新Redis中自动处理状态为false，新增正常处理标签
        boolean isConditionB3221 = conditionB3221(detail26List, mainRedis);
        updateTags(mainSid, mainRedis, false, isConditionB3221);
        // 更新子订单自动处理状态
        mainRedis.getDetailList().forEach(detail -> detail.setAutoProcessed(isConditionB3221));
    }

    /**
     * 更新标签
     */
    public static void updateTags(long mainSid, TOrdersMainRedis mainRedis, boolean isAllPrint, boolean isAll26Code){
        String tags = mainRedis.getTags();
        if (StringUtils.isNotBlank(tags)) {
            Set<String> tagSet = new HashSet<>(Arrays.asList(tags.split(",")));
            // 判断不做处理标签是否存在
            boolean hasNoProcessingTag = tagSet.contains(KmConstants.TAG_NO_PROCESSING);
            // 判断正常处理标签是否存在
            boolean hasNormalProcessingTag = tagSet.contains(KmConstants.TAG_NORMAL_PROCESSING);
            // 判断印刷品标签是否存在
            boolean hasPrintedTag = tagSet.contains(KmConstants.TAG_PRINTED);

            if (isAllPrint) {
                TagUtils.handleAllPrint(mainSid, hasNoProcessingTag, hasNormalProcessingTag, hasPrintedTag);
            } else {
                if (isAll26Code) {
                    TagUtils.handleAll26Code(mainSid, hasNoProcessingTag, hasNormalProcessingTag, hasPrintedTag);
                } else {
                    TagUtils.handleDefaultCase(mainSid, hasNoProcessingTag, hasNormalProcessingTag, hasPrintedTag);
                }
            }
        } else {
            if (isAllPrint) {
                TagUtils.handleAllPrint(mainSid, false, false, false);
            } else {
                if (isAll26Code) {
                    TagUtils.handleAll26Code(mainSid, false, false, false);
                } else {
                    TagUtils.handleDefaultCase(mainSid, false, false, false);
                }
            }
        }
    }


    /**
     * 获取26位编码订单集合
     */
    private static List<TOrdersDetail> get26CodeOrderList(List<TOrdersDetail> detailCollect){
        return detailCollect.stream().filter(detail -> detail.getOuterSkuId().matches("^[0-9a-zA-z]{26}$")).collect(Collectors.toList());
    }

    /**
     * 获取印刷品订单集合
     */
    public static List<TOrdersDetail> getPrintOrderList(List<TOrdersDetail> detailCollect, List<String> printList){
        return detailCollect.stream().filter(detail -> printList.stream().anyMatch(code -> StringUtils.contains(detail.getOuterSkuId(), code))).collect(Collectors.toList());
    }

    /**
     * 处理成功，更新Redis中自动处理状态为true，新增不做处理标签，删除正常处理标签，删除印刷品标签；
     */
    private static boolean conditionB3221(List<TOrdersDetail> detail26List, TOrdersMainRedis mainRedis){
        return detail26List.stream().allMatch(detail -> {
            try {
                // 只有明细中sid和Redis中sid一致且Redis中自动处理状态为false的才处理
                if (mainRedis.getDetailList().stream().anyMatch(detailRedis -> !detailRedis.isAutoProcessed() && (detail.getDetailSid() == detailRedis.getDetailSid()))) {
                    // 主系统订单号
                    long mainSid = detail.getMainSid();
                    // 子系统订单号
                    long sid = detail.getDetailSid();
                    // 订单SK信息
                    String sk = detail.getOuterSkuId();
                    // 订单数量
                    int orderNum = detail.getNum();
                    // 文件打包
                    return collectFiles(mainSid, sid, sk, orderNum, mainRedis);
                }
                return true;
            }catch (Exception e) {
                log.error("【打包失败】，错误信息--->{}", e.getMessage());
                return false;
            }
        });
    }

    /**
     * 文件打包
     */
    private static boolean collectFiles(long mainSid, long sid, String sk, int orderNum, TOrdersMainRedis mainRedis){
        // 获取商品对应的文件信息
        List<TProdRelDetails> prodRelList = RedisCacheUtils.getCacheObject(Constants.PROD_REL_REDIS_KEY + sk);
        if (CollectionUtils.isEmpty(prodRelList)) {
            return false;
        }
        AtomicReference<String> path = new AtomicReference<>();
        return prodRelList.stream().allMatch(prodRel -> {
            try{
                // 店铺id
                String shopId = prodRel.getShopId();
                // 材质id
                String matId = prodRel.getImgMaterial();
                // 文件id
                String imgId = prodRel.getImgId();
                // 数量
                int num = prodRel.getImgNum();
                // 尺寸
                String dim = prodRel.getImgDimensions();

                // 内部单号
                String shortId = mainRedis.getShortId();

                // 获取路径信息
                TPathRel pathRel = RedisCacheUtils.getCacheObject(Constants.PATH_REL_REDIS_KEY + matId);
                // 拷图格式
                String format = pathRel.getPathFormat();
                // 材质名称
                String matName = pathRel.getMatName();

                // 获取下载文件路径
                Map<String,String> filePathMap = getDownloadFilePath(imgId, format);

                // 生成文件打包路径
                path.set(genFilePath(pathRel, shopId, shortId, mainRedis));
                // 创建打包路径
                FileUtils.createDirectories(path.get());

                filePathMap.forEach((key,value)->{
                    String fileName = orderNum * num + "张 " + dim + " " + matName + key;
                    try {
                        // 真实文件名称
                        String realFileName = FileUtils.downloadFileFromHttpToSmb(value, path + "/" + fileName);
                        // 记录文件打包路径
                        SpringUtils.getBean(ITOrdersLogService.class).insertPath(mainSid, sid, "自动处理：打包成功", realFileName);
                    } catch (Exception e) {
                        log.error(e.getMessage());
                        throw new RuntimeException(e);
                    }

                });
                return true;
            }catch (Exception e) {
                FileUtils.deleteFromSmb(path.get() + "/");
                return false;
            }
        });

    }

    /**
     * 生成文件打包路径
     */
    private static String genFilePath(TPathRel pathRel,String shopId,String shortId, TOrdersMainRedis mainRedis){
        // 获取路径
        String path = pathRel.getPath();
        // 拆分后的路径
        String[] parts = splitPath(path);

        // 获取店铺信息
        TStoreMgmt storeMgmt = RedisCacheUtils.getCacheObject(Constants.STORE_REDIS_KEY + shopId);
        // 店铺对应的事业部
        String divName = storeMgmt.getDivName();
        // 店铺名称
        String storeName = mainRedis.getShopName();

        // 当前日期路径
        String datePath = DateUtils.getDatePath();

        // 文件存储路径
        String storagePath = RedisCacheUtils.getCacheObject(Constants.FILE_STORAGE_PATH);
        String localPath = "process/" + datePath + parts[0] + "/" + getShift() + "/" + divName + parts[1] + "/" + storeName + "/" + shortId + "+" + storeName;
        // 构建远程路径
        String localPathBuilder = "smb://192.168.2.2/自动处理/" +
                datePath +
                parts[0] +
                "/" +
                getShift() +
                "/" +
                divName +
                parts[1] +
                "/" +
                storeName +
                "/" +
                shortId +
                "+" +
                storeName;
        // 从Redis备注中获取是否有收据
        boolean isReceipt = mainRedis.getDetailList().stream().anyMatch(detailRedis -> StringUtils.contains(detailRedis.getSellerMemo(), "【收据】"));
        boolean isMainReceipt = StringUtils.contains(mainRedis.getSellerMemo(), "【收据】");
        if (isReceipt || isMainReceipt) {
            localPathBuilder += "+收据";
        }
        // 从Redis备注中获取是否有中通快递
        boolean isZhongTong = mainRedis.getDetailList().stream().anyMatch(detailRedis -> StringUtils.contains(detailRedis.getSellerMemo(), "【中通快递】"));
        boolean isMainZhongTong = StringUtils.contains(mainRedis.getSellerMemo(), "【中通快递】");
        if (isZhongTong || isMainZhongTong) {
            localPathBuilder += "+发中通快递";
        }
        // 从Redis备注中获取是否有顺丰到付和顺丰现付
        boolean isSfdf = mainRedis.getDetailList().stream().anyMatch(detailRedis -> StringUtils.equals(detailRedis.getSellerMemo(), "【顺丰到付】"));
        boolean isMainSfdf = StringUtils.equals(mainRedis.getSellerMemo(), "【顺丰到付】");
        if (isSfdf || isMainSfdf) {
            localPathBuilder += "+发顺丰到付快递";
        }
        boolean isSfxf = mainRedis.getDetailList().stream().anyMatch(detailRedis -> StringUtils.equals(detailRedis.getSellerMemo(), "【顺丰现付】"));
        boolean isMainSfxf = StringUtils.equals(mainRedis.getSellerMemo(), "【顺丰现付】");
        if (isSfxf || isMainSfxf) {
            localPathBuilder += "+发顺丰现付快递";
        }
        return localPathBuilder;
    }

    /**
     * 已经做包，且备注有【收据】，需要修改原文件路径和数据库记录的路径
     */
    private static void conditionB4(TOrdersMain ordersMain) {
        try {
            boolean isReceipt = ordersMain.getDetailList().stream().anyMatch(detail -> StringUtils.contains(detail.getSellerMemo(), "【收据】"));
            boolean isMainReceipt = StringUtils.contains(ordersMain.getSellerMemo(), "【收据】");
            if (isReceipt || isMainReceipt) {
                // 根据mainSid获取日志中的路径
                List<TOrdersLog> logs = SpringUtils.getBean(ITOrdersLogService.class).getFileDirectory(ordersMain.getSid(), "+收据");

                // 路径修改
                List<String> filePathList = logs.stream().map(TOrdersLog::getFilePath).distinct().collect(Collectors.toList());
                filePathList.forEach(filePath -> {
                    FileUtils.renameSmbPath(filePath + "/", filePath + "+收据/");
                });

                logs.forEach(log -> {
                    String id = log.getId();
                    // 路径
                    String filePath = log.getFilePath();
                    SpringUtils.getBean(ITOrdersLogService.class).updatePath(id, filePath, "+收据");

                });

            }
        }catch (Exception e) {
            log.error(e.getMessage());
        }

    }

    /**
     * 已经做包，且备注有【中通快递】，添加+发中通快递， 需要修改原文件路径和数据库记录的路径
     */
    private static void conditionB5(TOrdersMain ordersMain){
        try {
            boolean isReceipt = ordersMain.getDetailList().stream().anyMatch(detail -> StringUtils.contains(detail.getSellerMemo(), "【中通快递】"));
            boolean isMainReceipt = StringUtils.contains(ordersMain.getSellerMemo(), "【中通快递】");
            if (isReceipt || isMainReceipt) {
                // 根据mainSid获取日志中的路径
                List<TOrdersLog> logs = SpringUtils.getBean(ITOrdersLogService.class).getFileDirectory(ordersMain.getSid(), "+发中通快递");

                // 路径修改
                List<String> filePathList = logs.stream().map(TOrdersLog::getFilePath).distinct().collect(Collectors.toList());
                filePathList.forEach(filePath -> {
                    FileUtils.renameSmbPath(filePath + "/", filePath + "+发中通快递/");
                });

                logs.forEach(log -> {
                    String id = log.getId();
                    // 路径
                    String filePath = log.getFilePath();
                    SpringUtils.getBean(ITOrdersLogService.class).updatePath(id, filePath, "+发中通快递");

                });

            }
        }catch (Exception e) {
            log.error(e.getMessage());
        }
    }

    /**
     * 已经做包，且备注有【顺丰到付】【顺丰现付】，添加+发顺丰快递， 需要修改原文件路径和数据库记录的路径
     */
    private static void conditionB6(TOrdersMain ordersMain){

        // 顺丰到付
        conditionB61(ordersMain);

        // 顺丰现付
        conditionB62(ordersMain);

        // 顺丰空运到付
        conditionB63(ordersMain);



    }

    public static void conditionB61(TOrdersMain ordersMain){
        try {
            boolean isReceipt = ordersMain.getDetailList().stream().anyMatch(detail -> StringUtils.contains(detail.getSellerMemo(), "【顺丰到付】"));
            boolean isMainReceipt = StringUtils.contains(ordersMain.getSellerMemo(), "【顺丰到付】");
            if (isReceipt || isMainReceipt) {
                // 根据mainSid获取日志中的路径
                List<TOrdersLog> logs = SpringUtils.getBean(ITOrdersLogService.class).getFileDirectory(ordersMain.getSid(), "+发顺丰到付快递");

                // 路径修改
                List<String> filePathList = logs.stream().map(TOrdersLog::getFilePath).distinct().collect(Collectors.toList());
                filePathList.forEach(filePath -> {
                    FileUtils.renameSmbPath(filePath + "/", filePath + "+发顺丰到付快递/");
                });

                logs.forEach(log -> {
                    String id = log.getId();
                    // 路径
                    String filePath = log.getFilePath();
                    SpringUtils.getBean(ITOrdersLogService.class).updatePath(id, filePath, "+发顺丰到付快递");

                });

            }
        }catch (Exception e) {
            log.error(e.getMessage());
        }
    }

    public static void conditionB62(TOrdersMain ordersMain){
        boolean isReceipt = ordersMain.getDetailList().stream().anyMatch(detail -> StringUtils.contains(detail.getSellerMemo(), "【顺丰现付】"));
        boolean isMainReceipt = StringUtils.contains(ordersMain.getSellerMemo(), "【顺丰现付】");
        if (isReceipt || isMainReceipt) {
            // 根据mainSid获取日志中的路径
            List<TOrdersLog> logs = SpringUtils.getBean(ITOrdersLogService.class).getFileDirectory(ordersMain.getSid(), "+发顺丰现付快递");

            // 路径修改
            List<String> filePathList = logs.stream().map(TOrdersLog::getFilePath).distinct().collect(Collectors.toList());
            filePathList.forEach(filePath -> {
                FileUtils.renameSmbPath(filePath + "/", filePath + "+发顺丰现付快递/");
            });

            logs.forEach(log -> {
                String id = log.getId();
                // 路径
                String filePath = log.getFilePath();
                SpringUtils.getBean(ITOrdersLogService.class).updatePath(id, filePath, "+发顺丰现付快递");

            });

        }
    }

    public static void conditionB63(TOrdersMain ordersMain){
        boolean isReceipt = ordersMain.getDetailList().stream().anyMatch(detail -> StringUtils.contains(detail.getSellerMemo(), "【顺丰空运到付】"));
        boolean isMainReceipt = StringUtils.contains(ordersMain.getSellerMemo(), "【顺丰空运到付】");
        if (isReceipt || isMainReceipt) {
            // 根据mainSid获取日志中的路径
            List<TOrdersLog> logs = SpringUtils.getBean(ITOrdersLogService.class).getFileDirectory(ordersMain.getSid(), "+发顺丰空运到付");

            // 路径修改
            List<String> filePathList = logs.stream().map(TOrdersLog::getFilePath).distinct().collect(Collectors.toList());
            filePathList.forEach(filePath -> {
                FileUtils.renameSmbPath(filePath + "/", filePath + "+发顺丰空运到付/");
            });

            logs.forEach(log -> {
                String id = log.getId();
                // 路径
                String filePath = log.getFilePath();
                SpringUtils.getBean(ITOrdersLogService.class).updatePath(id, filePath, "+发顺丰空运到付");

            });

        }
    }

    /**
     * 拆分路径
     */
    public static String[] splitPath(String path){
        String[] parts = path.split("/", 3); // 使用正斜杠分割，限制分割次数为3
        String part1 = "/" + parts[1]; // 第一部分
        String part2 = "/" + parts[2]; // 第二部分
        return new String[]{part1,part2};
    }

    /**
     * 判断班次
     */
    public static String getShift(){
        // 获取当前时间
        LocalTime currentTime = LocalTime.now();
        // 获取班次信息
        List<TShiftMgmt> shiftMgmtList = RedisCacheUtils.getCacheObject(Constants.SHIFT_REDIS_KEY);
        // 遍历班次，判断当前时间属于哪个班次
        for (TShiftMgmt shift : shiftMgmtList) {
            // 处理跨天班次的情况
            if (shift.getEndTime().isBefore(shift.getStartTime())) {
                // 如果班次结束时间早于开始时间，说明班次跨越午夜
                if (currentTime.isAfter(shift.getStartTime()) || currentTime.isBefore(shift.getEndTime())) {
                    return shift.getShiftName();
                }
            } else {
                // 普通班次
                if (currentTime.isAfter(shift.getStartTime()) && currentTime.isBefore(shift.getEndTime())) {
                    return shift.getShiftName();
                }
            }
        }
        return "当前时间不属于任何班次";
    }

    /**
     * 根据拷图格式获取下载文件路径
     */
    private static Map<String, String> getDownloadFilePath(String imgId, String format){
        Map<String, String> downloadPath = new HashMap<>();
        // 获取文件信息
        TImagesInfo imagesInfo = SpringUtils.getBean(ITImagesInfoService.class).getNormalImgInfoById(imgId);
        if (imagesInfo != null) {
            if (StringUtils.equals(format, ".jpg")) {
                downloadPath.put(format, imagesInfo.getBucketUrl() + imagesInfo.getImgJpgPath());
            } else if (StringUtils.equals(format, ".cdr")) {
                downloadPath.put(format, imagesInfo.getBucketUrl() + imagesInfo.getImgSourcePath());
                downloadPath.put(".png", imagesInfo.getBucketUrl() + imagesInfo.getImgPngPath());
            } else {
                downloadPath.put(format, imagesInfo.getBucketUrl() + imagesInfo.getImgSourcePath());
            }
        }

        return downloadPath;

    }

    /**
     * 根据mainSid删除打包文件
     */
    public static void delFileByMainSid(TOrdersMain ordersMain){
        List<TOrdersLog> filePathList = SpringUtils.getBean(ITOrdersLogService.class).getFilePathByMainSid(ordersMain.getSid());
        if (!filePathList.stream().allMatch(Objects::isNull)) {
            // 获取第一条做包时间
            long firstCreated = filePathList.get(0).getCreated();
            delFiles(filePathList, ordersMain.getSid(), ordersMain.getSid());
            // 交易成功的，不发送微信消息
            if (!StringUtils.equals(ordersMain.getSysStatus(), "FINISHED")) {
                // 判断created
                String operation = getOperation(firstCreated);
                // 发送微信提醒
                WeChatUtil.sendMarkDownTextMsg(Objects.requireNonNull(OrdersStatusEnum.fromStatus(ordersMain.getSysStatus())).getDescription(), ordersMain, operation);
            }
        }


    }

    /**
     * 根据sid删除打包文件
     */
    public static void delFileBySid(TOrdersMain ordersMain, long sid){
        List<TOrdersLog> filePathList = SpringUtils.getBean(ITOrdersLogService.class).getFilePathBySid(sid);
        if (!filePathList.stream().allMatch(Objects::isNull)) {
            // 获取第一条做包时间
            long firstCreated = filePathList.get(0).getCreated();
            delFiles(filePathList, ordersMain.getSid(), ordersMain.getSid());
            // 交易成功的，不发送微信消息
            if (!StringUtils.equals(ordersMain.getSysStatus(), "FINISHED")) {
                // 判断created
                String operation = getOperation(firstCreated);
                // 发送微信提醒
                WeChatUtil.sendMarkDownTextMsg(Objects.requireNonNull(OrdersStatusEnum.fromStatus(ordersMain.getSysStatus())).getDescription(), ordersMain, operation);
            }
        }

    }

    /**
     * 删除打包文件
     */
    public static void delFiles(List<TOrdersLog> filePathList, long mainSid, long sid){
        if (!filePathList.stream().allMatch(Objects::isNull)) {
            // 删除打包文件
            for (TOrdersLog log : filePathList) {
                // 更新打包文件状态 0：未删除 1：已删除
                SpringUtils.getBean(ITOrdersLogService.class).updateStatus(log.getId(), '1');
                int deletedCount = FileUtils.deleteFromSmb(log.getFilePath());
                if (deletedCount > 0) {
                    // 写日志
                    SpringUtils.getBean(ITOrdersLogService.class).insert(mainSid, sid, "自动处理：删除打包文件", 0);
                }
            }


        }
    }

    /**
     * 根据时间戳获取操作
     */
    public static String getOperation(long timestamp) {
        LocalDateTime dateTime = LocalDateTime.ofInstant(java.time.Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
        LocalTime time = dateTime.toLocalTime();
        LocalTime now = LocalTime.now();

        // 获取班次信息
        List<TShiftMgmt> shiftMgmtList = RedisCacheUtils.getCacheObject(Constants.SHIFT_REDIS_KEY);

        // 判断是否为当天
        if (dateTime.toLocalDate().equals(LocalDateTime.now().toLocalDate())) {
            // 判断班次
            for (TShiftMgmt shift : shiftMgmtList) {
                if (isWithinShift(time, shift.getStartTime(), shift.getEndTime())) {
                    if (isWithinShift(now, shift.getStartTime(), shift.getEndTime())) {
                        return "拷图前删包";
                    }
                }
            }
        }
        return "拷图后删包";
    }

    /**
     * 判断时间是否在班次内
     */
    private static boolean isWithinShift(LocalTime time, LocalTime start, LocalTime end) {
        if (start.isBefore(end)) {
            return !time.isBefore(start) && !time.isAfter(end);
        } else {
            return !time.isBefore(start) || !time.isAfter(end);
        }
    }

}
